<?php

/**
 * BUDDYPRESS MOCK CLASS - ACTIONS AND FILTERS
 * A fully instrumented debug class that replaces BP-Media's wpFilters bridge singleton
 * 
 * @version 0.1.9
 * @since 0.1.9
 * @author an object-oriented version of "plugin.php" from the WordPress core 
 * @package Unit Test
 * @subpackage Mock Classes
 * @license GPL v2.0
 * @link http://code.google.com/p/buddypress-media/
 *
 * ========================================================================================================
 */

class mock_BPM_wpFilters {

    
	var $errors_enable = true;		    // True to enable error-checking on function inputs
	var $error_log_enable = true;		    // True to log function call errors
	var $error_log;				    // Logged errors array
	
	var $start_time;			    // Time the trace was started
	
	var $trace_targets = array();		    // Array of function names to trace
	var $trace_buffer;			    // The current action stack trace
	
	var $wp_filter;				    // Stores all of the filters added in the form of 
						    // wp_filter['tag']['array of priorities']['array of functions serialized']['array of ['array (functions, accepted_args)']']
	
	var $merged_filters;			    // Tracks the tags that need to be merged for later. If the hook is added, 
						    // it doesn't need to run through that process.
	
	var $wp_current_filter;			    // Stores the list of current filters with the current one last
	
	var $wp_actions;			    // Increments the amount of times action was triggered
	
	var $uninstall_plugins;			    // Plugins with saved uninstall hooks


	// ============================================================================================================ //
    
    


	function startTrace() {


	}

	function stopTrace() {


	}

	function dumpTrace($args) {

	    if($args['format'] == 'terse'){
		
		
	    }

	}   
	
	

	function setTrap() {


	} 

	function clearTrap() {


	}     

	/**
	* Hooks a function or method to a specific filter action.
	*
	* @version 0.1.9
	* @since 0.1.9
	* @param string $tag The name of the filter to hook the $function_to_add to.
	* @param callback $function_to_add The name of the function to be called when the filter is applied.
	* @param int $priority optional. Used to specify the order in which the functions associated with a particular action are executed (default: 10). Lower numbers correspond with earlier execution, and functions with the same priority are executed in the order in which they were added to the action.
	* @param int $accepted_args optional. The number of arguments the function accept (default 1).
	* @return bool | Exception on failure, if enabled. True on success.
	*/
	public function add_filter($tag, $function_to_add, $priority=10, $accepted_args=1) {
	    
	    
		if($this->errors_enable){
		    
			$in_error = false;
		    
			if( !$tag || !is_string($tag) ){

				$error = array(
					'numeric'=>1,
					'text'=>"Bad 'tag' parameter",
					'data'=> array('tag'=>$tag, 'function_to_add'=>$function_to_add, 
							'priority'=>$priority, 'accepted_args'=>$accepted_args),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);				
				
				$in_error = true;				
			}
			
			if( !$function_to_add || !is_string($function_to_add) ){

				$error = array(
					'numeric'=>2,
					'text'=>"Bad 'function_to_add' parameter",
					'data'=> array('tag'=>$tag, 'function_to_add'=>$function_to_add, 
							'priority'=>$priority, 'accepted_args'=>$accepted_args),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);
				
				$in_error = true;				
			}
			
			if( !is_int($priority) ){

				$error = array(
					'numeric'=>3,
					'text'=>"Bad 'priority' parameter",
					'data'=> array('tag'=>$tag, 'function_to_add'=>$function_to_add, 
							'priority'=>$priority, 'accepted_args'=>$accepted_args),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);
				
				$in_error = true;					
			}
			
			if( !is_int($accepted_args) ){

				$error = array(
					'numeric'=>4,
					'text'=>"Bad 'accepted_args' parameter",
					'data'=> array('tag'=>$tag, 'function_to_add'=>$function_to_add, 
							'priority'=>$priority, 'accepted_args'=>$accepted_args),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);
				
				$in_error = true;					
			}
			
			if($in_error){
			    
				if($this->error_log_enable){
				    
					$backtrace = debug_backtrace();
					
					$this->error_log[] = array(
					    
						'function' => $backtrace[0]['function'],					    
						'caller' => $backtrace[1],
						'error' => $error
					);
				}
				
				throw new RAZ_exception($error);
			}
			
		} // ENDOF: if($this->enable_errors)
		
		
		$idx = self::build_unique_id($tag, $function_to_add, $priority);		
		$this->wp_filter[$tag][$priority][$idx] = array('function' => $function_to_add, 'accepted_args' => $accepted_args);
		unset( $this->merged_filters[$tag] );
		
		if( array_key_exists('add_filter', $this->trace_targets) ){
		    
			$backtrace = debug_backtrace();
					
			$this->trace_buffer[] = array( 
						'op'=>$backtrace[0]['function'],
						'time'=>microtime(),
						'filter_name'=>$tag,
						'function_name'=>$function_to_add,
						'args'=>$accepted_args,
						'guid'=>$idx,
						'caller'=>$backtrace[1]
			);
		}
				
		return true;
		
	}

	/**
	* Check if any filter has been registered for a hook.
	*
	* @version 0.1.9
	* @since 0.1.9
	* @param string $tag | The name of the filter hook.
	* @param string $function_to_check | If specified, return the priority of that function on this hook or false if not attached.
	* @return bool/int | Exception on failure. Optionally returns the priority on that hook for the specified function.
	*/
	public function has_filter($tag, $function_to_check=false) {
	    
	    
		if($this->errors_enable){
		    
			$in_error = false;
		    
			if( !$tag || !is_string($tag) ){

				$error = array(
					'numeric'=>1,
					'text'=>"Bad 'tag' parameter",
					'data'=> array('tag'=>$tag, 'function_to_check'=>$function_to_check),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);				
				
				$in_error = true;				
			}
			
			if( ($function_to_check !== false) && !is_string($function_to_check) ){

				$error = array(
					'numeric'=>2,
					'text'=>"Bad 'function_to_check' parameter",
					'data'=> array('tag'=>$tag, 'function_to_check'=>$function_to_check),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);
				
				$in_error = true;				
			}			
			
			if($in_error){
			    
				if($this->error_log_enable){
				    
					$backtrace = debug_backtrace();
					
					$this->error_log[] = array(
					    
						'function' => $backtrace[0]['function'],					    
						'caller' => $backtrace[1],
						'error' => $error
					);
				}
				
				throw new RAZ_exception($error);
			}
			
		} // ENDOF: if($this->enable_errors)
		
		
		if( array_key_exists('has_filter', $this->trace_targets) ){
		    
			$backtrace = debug_backtrace();
					
			$this->trace_buffer[] = array( 
						'op'=>$backtrace[0]['function'],
						'time'=>microtime(),
						'filter_name'=>$tag,
						'function_name'=>$function_to_check,
						'caller'=>$backtrace[1]
			);
		}		
		
		
		$has = !empty($this->wp_filter[$tag]);
		
		if( ($function_to_check === false)  || ($has == false) ){
		    
			return $has;
		}

		if( !$idx = self::build_unique_id($tag, $function_to_check, false) ){
		    
			return false;
		}

		foreach( (array) array_keys($this->wp_filter[$tag]) as $priority ) {
		    
			if( isset($this->wp_filter[$tag][$priority][$idx]) ){
			    
				return $priority;
			}
		}

		return false;
		
	}

	/**
	* Call the functions added to a filter hook.
	*
	* The callback functions attached to filter hook $tag are invoked by calling
	* this function. This function can be used to create a new filter hook by
	* simply calling this function with the name of the new hook specified using
	* the $tag parameter. The function allows for additional arguments to be added 
	* and passed to hooks. Example:
	* 
	* $value = apply_filters('example_filter', 'filter me', 'arg1', 'arg2');
	*
	* @version 0.1.9
	* @since 0.1.9
	* @param string $tag | The name of the filter hook.
	* @param mixed $value | The value on which the filters hooked to <tt>$tag</tt> are applied on.
	* @param mixed $var,... | Additional variables passed to the functions hooked to <tt>$tag</tt>.
	* @return mixed | Exception on failure, if enabled. The filtered value after all hooked functions are applied to it.
	*/
	public function apply_filters($tag, $value) {

	    
		if($this->errors_enable){
		    
			if( !$tag || !is_string($tag) ){

				$error = array(
					'numeric'=>1,
					'text'=>"Bad 'tag' parameter",
					'data'=> array('tag'=>$tag, 'args'=>func_get_args() ),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);				
				
			    
				if($this->error_log_enable){
				    
					$backtrace = debug_backtrace();
					
					$this->error_log[] = array(
					    
						'function' => $backtrace[0]['function'],					    
						'caller' => $backtrace[1],
						'error' => $error
					);
				}
				
				throw new RAZ_exception($error);
			}
		}
		
		if( array_key_exists('apply_filters', $this->trace_targets) ){
		    
			$backtrace = debug_backtrace();
					
			$this->trace_buffer[] = array( 
						'op'=>$backtrace[0]['function'],
						'time'=>microtime(),
						'filter_name'=>$tag,
						'args'=>func_get_args(),
						'caller'=>$backtrace[1]
			);
		}
		
		
		$args = array();

		// Do 'all' actions first
		if( isset($this->wp_filter['all']) ) {
		    
			$this->wp_current_filter[] = $tag;
			$args = func_get_args();
			
			self::call_all_hook($args);
			
		}

		if( !isset($this->wp_filter[$tag]) ) {
		    
			if( isset($this->wp_filter['all']) ){
				array_pop($this->wp_current_filter);
			}
			
			return $value;
		}

		if( !isset($this->wp_filter['all']) ){
			$this->wp_current_filter[] = $tag;
		}

		// Sort
		if( !isset( $this->merged_filters[ $tag ] ) ) {
		    
			ksort($this->wp_filter[$tag]);
			$this->merged_filters[ $tag ] = true;
			
		}

		reset( $this->wp_filter[ $tag ] );

		if( empty($args) ){
			$args = func_get_args();
		}

		do {
			foreach( (array) current($this->wp_filter[$tag]) as $the_ ){
			    
				if( !is_null($the_['function']) ){
				    
					$args[1] = $value;
					$value = call_user_func_array($the_['function'], array_slice($args, 1, (int) $the_['accepted_args']));
				}
			}

		} while( next($this->wp_filter[$tag]) !== false );

		array_pop( $this->wp_current_filter );

		return $value;
		
	}

	/**
	* Execute functions hooked on a specific filter hook, specifying arguments in an array.
	*
	* @see apply_filters() This function is identical, but the arguments passed to the
	* functions hooked to <tt>$tag</tt> are supplied using an array.
	*
	* @version 0.1.9
	* @since 0.1.9
	* @param string $tag The name of the filter hook.
	* @param array $args The arguments supplied to the functions hooked to <tt>$tag</tt>
	* @return mixed | Exception on failure, if enabled. The filtered value after all hooked functions are applied to it.
	*/
	
	public function apply_filters_ref_array($tag, $args) {
	    
	    
		if($this->errors_enable){
		    
			if( !$tag || !is_string($tag) ){

				$error = array(
					'numeric'=>1,
					'text'=>"Bad 'tag' parameter",
					'data'=> array('tag'=>$tag, 'args'=>func_get_args() ),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);				
				
			    
				if($this->error_log_enable){
				    
					$backtrace = debug_backtrace();
					
					$this->error_log[] = array(
					    
						'function' => $backtrace[0]['function'],					    
						'caller' => $backtrace[1],
						'error' => $error
					);
				}
				
				throw new RAZ_exception($error);
			}
		}
		
		if( array_key_exists('apply_filters_ref_array', $this->trace_targets) ){
		    
			$backtrace = debug_backtrace();
					
			$this->trace_buffer[] = array( 
						'op'=>$backtrace[0]['function'],
						'time'=>microtime(),
						'filter_name'=>$tag,
						'args'=>$args,
						'caller'=>$backtrace[1]
			);
		}
		
		
		// Do 'all' actions first
		if( isset($this->wp_filter['all']) ){
		    
			$this->wp_current_filter[] = $tag;
			$all_args = func_get_args();
			
			self::call_all_hook($all_args);
			
		}

		if( !isset($this->wp_filter[$tag]) ){
		    
			if( isset($this->wp_filter['all']) ){
			    
				array_pop($this->wp_current_filter);
			}
			return $args[0];
			
		}

		if( !isset($this->wp_filter['all']) ){
		    
			$this->wp_current_filter[] = $tag;
		}

		// Sort
		if( !isset( $this->merged_filters[ $tag ] ) ){
		    
			ksort($this->wp_filter[$tag]);
			$this->merged_filters[ $tag ] = true;
		}

		reset( $this->wp_filter[ $tag ] );

		do {
			foreach( (array) current($this->wp_filter[$tag]) as $the_ ){
			    
				if( !is_null($the_['function']) ){
				    
					$args[0] = call_user_func_array($the_['function'], array_slice($args, 0, (int) $the_['accepted_args']));
				}
			}

		} while ( next($this->wp_filter[$tag]) !== false );

		array_pop( $this->wp_current_filter );

		return $args[0];
		
	}

	
	/**
	* Removes a function from a specified filter hook.
	*
	* This function removes a function attached to a specified filter hook. This
	* method can be used to remove default functions attached to a specific filter
	* hook and possibly replace them with a substitute.
	*
	* To remove a hook, the $function_to_remove and $priority arguments must match
	* when the hook was added. This goes for both filters and actions. 
	 * 
	* @version 0.1.9
	* @since 0.1.9
	* @param string $tag The filter hook to which the function to be removed is hooked.
	* @param callback $function_to_remove The name of the function which should be removed.
	* @param int $priority optional. The priority of the function (default: 10).
	* @return boolean Whether the function existed before it was removed.
	*/
	
	public function remove_filter($tag, $function_to_remove, $priority=10) {
	    
	    
		if($this->errors_enable){
		    
			$in_error = false;
		    
			if( !$tag || !is_string($tag) ){

				$error = array(
					'numeric'=>1,
					'text'=>"Bad 'tag' parameter",
					'data'=> array('tag'=>$tag, 'function_to_remove'=>$function_to_remove, 
							'priority'=>$priority),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);				
				
				$in_error = true;				
			}
			
			if( !$function_to_remove || !is_string($function_to_remove) ){

				$error = array(
					'numeric'=>2,
					'text'=>"Bad 'function_to_remove' parameter",
					'data'=> array('tag'=>$tag, 'function_to_remove'=>$function_to_remove, 
							'priority'=>$priority),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);
				
				$in_error = true;				
			}
			
			if( !is_int($priority) ){

				$error = array(
					'numeric'=>3,
					'text'=>"Bad 'priority' parameter",
					'data'=> array('tag'=>$tag, 'function_to_remove'=>$function_to_remove, 
							'priority'=>$priority),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);
				
				$in_error = true;					
			}			
			
			if($in_error){
			    
				if($this->error_log_enable){
				    
					$backtrace = debug_backtrace();
					
					$this->error_log[] = array(
					    
						'function' => $backtrace[0]['function'],					    
						'caller' => $backtrace[1],
						'error' => $error
					);
				}
				
				throw new RAZ_exception($error);
			}
			
		} // ENDOF: if($this->enable_errors)
		
		
		if( array_key_exists('remove_filter', $this->trace_targets) ){
		    
			$backtrace = debug_backtrace();
					
			$this->trace_buffer[] = array( 
						'op'=>$backtrace[0]['function'],
						'time'=>microtime(),
						'filter_name'=>$tag,
						'function_to_remove'=>$function_to_remove,			    
						'priority'=>$priority,
						'caller'=>$backtrace[1]
			);
		}
		
		$function_to_remove = self::build_unique_id($tag, $function_to_remove, $priority);

		$r = isset($GLOBALS['wp_filter'][$tag][$priority][$function_to_remove]);

		if( true === $r) {
		    
			unset($GLOBALS['wp_filter'][$tag][$priority][$function_to_remove]);
			
			if( empty($GLOBALS['wp_filter'][$tag][$priority]) ){
			    
				unset($GLOBALS['wp_filter'][$tag][$priority]);
			}
			
			unset($GLOBALS['merged_filters'][$tag]);
		}

		return $r;
		
	}

	
	/**
	* Remove all of the hooks from a filter.
	*
	* @version 0.1.9
	* @since 0.1.9
	* @param string $tag | The filter to remove hooks from.
	* @param int $priority | The priority number to remove.
	* @return bool | Exception on failure, if enabled. True when finished.
	*/
	
	public function remove_all_filters($tag, $priority=false) {
	    
	    
		if($this->errors_enable){
		    
			$in_error = false;
		    
			if( !$tag || !is_string($tag) ){

				$error = array(
					'numeric'=>1,
					'text'=>"Bad 'tag' parameter",
					'data'=> array('tag'=>$tag, 'priority'=>$priority),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);				
				
				$in_error = true;				
			}		
			
			if( !is_int($priority) ){

				$error = array(
					'numeric'=>2,
					'text'=>"Bad 'priority' parameter",
					'data'=> array('tag'=>$tag, 'priority'=>$priority),
					'file'=>__FILE__, 'line'=>__LINE__, 'method'=>__METHOD__,
					'child'=>null
				);
				
				$in_error = true;					
			}			
			
			if($in_error){
			    
				if($this->error_log_enable){
				    
					$backtrace = debug_backtrace();
					
					$this->error_log[] = array(
					    
						'function' => $backtrace[0]['function'],					    
						'caller' => $backtrace[1],
						'error' => $error
					);
				}
				
				throw new RAZ_exception($error);
			}
			
		} // ENDOF: if($this->enable_errors)
		
		
		if( array_key_exists('remove_all_filters', $this->trace_targets) ){
		    
			$backtrace = debug_backtrace();
					
			$this->trace_buffer[] = array( 
						'op'=>$backtrace[0]['function'],
						'time'=>microtime(),
						'filter_name'=>$tag,		    
						'priority'=>$priority,
						'caller'=>$backtrace[1]
			);
		}
		
		
		if( isset($this->wp_filter[$tag]) ) {
		    
			if( false !== $priority && isset($this->wp_filter[$tag][$priority]) ){
				unset($this->wp_filter[$tag][$priority]);
			}
			else {
				unset($this->wp_filter[$tag]);
			}
		}

		if( isset($this->merged_filters[$tag]) ){
		    
			unset($this->merged_filters[$tag]);
		}

		return true;
		
	}

	/**
	* Retrieve the name of the current filter or action.
	*
	* @version 0.1.9
	* @since 0.1.9
	* @return string | Hook name of the current filter or action.
	*/
	
	public function current_filter() {
	    
	    
		if( array_key_exists('current_filter', $this->trace_targets) ){
		    
			$backtrace = debug_backtrace();
					
			$this->trace_buffer[] = array( 
						'op'=>$backtrace[0]['function'],
						'time'=>microtime(),
						'caller'=>$backtrace[1]
			);
		}
		
		return end( $this->wp_current_filter );
		
	}

	/**
	* Hooks a function on to a specific action.
	*
	* Actions are the hooks that the WordPress core launches at specific points
	* during execution, or when specific events occur. Plugins can specify that
	* one or more of its PHP functions are executed at these points, using the
	* Action API.
	*
	* @uses add_filter() Adds an action. Parameter list and functionality are the same.
	*
	* @package WordPress
	* @subpackage Plugin
	* @since 1.2
	*
	* @param string $tag The name of the action to which the $function_to_add is hooked.
	* @param callback $function_to_add The name of the function you wish to be called.
	* @param int $priority optional. Used to specify the order in which the functions associated with a particular action are executed (default: 10). Lower numbers correspond with earlier execution, and functions with the same priority are executed in the order in which they were added to the action.
	* @param int $accepted_args optional. The number of arguments the function accept (default 1).
	*/
	
	public function add_action($tag, $function_to_add, $priority=10, $accepted_args=1) {
	    
		return self::add_filter($tag, $function_to_add, $priority, $accepted_args);
	}

	/**
	* Execute functions hooked on a specific action hook.
	*
	* This function invokes all functions attached to action hook $tag. It is
	* possible to create new action hooks by simply calling this function,
	* specifying the name of the new hook using the <tt>$tag</tt> parameter.
	*
	* You can pass extra arguments to the hooks, much like you can with
	* apply_filters().
	*
	* @see apply_filters() This function works similar with the exception that
	* nothing is returned and only the functions or methods are called.
	*
	* @package WordPress
	* @subpackage Plugin
	* @since 1.2
	* @global array $this->wp_filter Stores all of the filters
	* @global array $this->wp_actions Increments the amount of times action was triggered.
	*
	* @param string $tag The name of the action to be executed.
	* @param mixed $arg,... Optional additional arguments which are passed on to the functions hooked to the action.
	* @return null Will return null if $tag does not exist in $this->wp_filter array
	*/
	
	public function do_action($tag, $arg = '') {
	    
		if( ! isset($this->wp_actions) ){
		    
			$this->wp_actions = array();
		}

		if( ! isset($this->wp_actions[$tag]) ){
		    
			$this->wp_actions[$tag] = 1;
		}
		else {
			$this->wp_actions[$tag]++;
		}

		// Do 'all' actions first
		if( isset($this->wp_filter['all']) ) {
		    
			$this->wp_current_filter[] = $tag;
			$all_args = func_get_args();
			
			self::call_all_hook($all_args);
		}

		if( !isset($this->wp_filter[$tag]) ) {
		    
			if( isset($this->wp_filter['all']) ){
			    
				array_pop($this->wp_current_filter);
			}
			
			return;
		}

		if( !isset($this->wp_filter['all']) ){
		    
			$this->wp_current_filter[] = $tag;
		}

		$args = array();
		
		if( is_array($arg) && 1 == count($arg) && isset($arg[0]) && is_object($arg[0]) ) { // array(&$this)
			$args[] =& $arg[0];
		}
		else {
			$args[] = $arg;
		}
		
		for( $a = 2; $a < func_num_args(); $a++ ){
		    
			$args[] = func_get_arg($a);
		}

		// Sort
		if( !isset( $this->merged_filters[ $tag ] ) ){
		    
			ksort($this->wp_filter[$tag]);
			$this->merged_filters[ $tag ] = true;
		}

		reset( $this->wp_filter[ $tag ] );

		do {
			foreach( (array) current($this->wp_filter[$tag]) as $the_ ){
			    
				if( !is_null($the_['function']) ){
				    
					call_user_func_array($the_['function'], array_slice($args, 0, (int) $the_['accepted_args']));
				}
			}

		} while ( next($this->wp_filter[$tag]) !== false );

		array_pop($this->wp_current_filter);
		
	}

	/**
	* Retrieve the number of times an action is fired.
	*
	* @package WordPress
	* @subpackage Plugin
	* @since 2.1
	* @global array $this->wp_actions Increments the amount of times action was triggered.
	*
	* @param string $tag The name of the action hook.
	* @return int The number of times action hook <tt>$tag</tt> is fired
	*/
	
	public function did_action($tag) {
	    

		if( !isset( $this->wp_actions ) || !isset( $this->wp_actions[$tag] ) ){
		    
			return 0;
		}

		return $this->wp_actions[$tag];
		
	}

	/**
	* Execute functions hooked on a specific action hook, specifying arguments in an array.
	*
	* @see do_action() This function is identical, but the arguments passed to the
	* functions hooked to <tt>$tag</tt> are supplied using an array.
	*
	* @package WordPress
	* @subpackage Plugin
	* @since 2.1
	* @global array $this->wp_filter Stores all of the filters
	* @global array $this->wp_actions Increments the amount of times action was triggered.
	*
	* @param string $tag The name of the action to be executed.
	* @param array $args The arguments supplied to the functions hooked to <tt>$tag</tt>
	* @return null Will return null if $tag does not exist in $this->wp_filter array
	*/
	
	public function do_action_ref_array($tag, $args) {
	   

		if( ! isset($this->wp_actions) ){
		    
			$this->wp_actions = array();
		}

		if( ! isset($this->wp_actions[$tag]) ){
		    
			$this->wp_actions[$tag] = 1;
		}
		else {
			$this->wp_actions[$tag]++;
		}

		// Do 'all' actions first
		if( isset($this->wp_filter['all']) ){
		    
			$this->wp_current_filter[] = $tag;
			$all_args = func_get_args();
			
			self::call_all_hook($all_args);
			
		}

		if( !isset($this->wp_filter[$tag]) ) {
		    
			if( isset($this->wp_filter['all']) ){
			    
				array_pop($this->wp_current_filter);
			}
			
			return;
		}

		if( !isset($this->wp_filter['all']) ){
		    
			$this->wp_current_filter[] = $tag;
		}

		// Sort
		if( !isset( $this->merged_filters[ $tag ] ) ){
		    
			ksort($this->wp_filter[$tag]);
			$this->merged_filters[ $tag ] = true;
		}

		reset( $this->wp_filter[ $tag ] );

		do {
			foreach( (array) current($this->wp_filter[$tag]) as $the_ ){
			    
				if( !is_null($the_['function']) ){
				    
					call_user_func_array($the_['function'], array_slice($args, 0, (int) $the_['accepted_args']));
				}
			}

		} while ( next($this->wp_filter[$tag]) !== false );

		array_pop($this->wp_current_filter);
		
	}

	/**
	* Check if any action has been registered for a hook.
	*
	* @package WordPress
	* @subpackage Plugin
	* @since 2.5
	* @see has_filter() has_action() is an alias of has_filter().
	*
	* @param string $tag The name of the action hook.
	* @param callback $function_to_check optional. If specified, return the priority of that function on this hook or false if not attached.
	* @return int|boolean Optionally returns the priority on that hook for the specified function.
	*/
	
	public function has_action($tag, $function_to_check = false) {
	    
		return self::has_filter($tag, $function_to_check);
	}

	/**
	* Removes a function from a specified action hook.
	*
	* This function removes a function attached to a specified action hook. This
	* method can be used to remove default functions attached to a specific filter
	* hook and possibly replace them with a substitute.
	*
	* @package WordPress
	* @subpackage Plugin
	* @since 1.2
	*
	* @param string $tag The action hook to which the function to be removed is hooked.
	* @param callback $function_to_remove The name of the function which should be removed.
	* @param int $priority optional The priority of the function (default: 10).
	* @param int $accepted_args optional. The number of arguments the function accepts (default: 1).
	* @return boolean Whether the function is removed.
	*/
	
	public function remove_action($tag, $function_to_remove, $priority = 10, $accepted_args = 1) {
	    
		return self::remove_filter($tag, $function_to_remove, $priority, $accepted_args);
		
	}

	/**
	* Remove all of the hooks from an action.
	*
	* @since 2.7
	*
	* @param string $tag The action to remove hooks from.
	* @param int $priority The priority number to remove them from.
	* @return bool True when finished.
	*/
	public function remove_all_actions($tag, $priority = false) {
	    
		return self::remove_all_filters($tag, $priority);
		
	}

	//
	// Functions for handling plugins.
	//

	/**
	* Gets the basename of a plugin.
	*
	* This method extracts the name of a plugin from its filename.
	*
	* @package WordPress
	* @subpackage Plugin
	* @since 1.5
	*
	* @access private
	*
	* @param string $file The filename of plugin.
	* @return string The name of a plugin.
	* @uses WP_PLUGIN_DIR
	*/
	
	public function plugin_basename($file) {
	    
		$file = str_replace('\\','/',$file); // sanitize for Win32 installs
		$file = preg_replace('|/+|','/', $file); // remove any duplicate slash
		$plugin_dir = str_replace('\\','/',WP_PLUGIN_DIR); // sanitize for Win32 installs
		$plugin_dir = preg_replace('|/+|','/', $plugin_dir); // remove any duplicate slash
		$mu_plugin_dir = str_replace('\\','/',WPMU_PLUGIN_DIR); // sanitize for Win32 installs
		$mu_plugin_dir = preg_replace('|/+|','/', $mu_plugin_dir); // remove any duplicate slash
		$file = preg_replace('#^' . preg_quote($plugin_dir, '#') . '/|^' . preg_quote($mu_plugin_dir, '#') . '/#','',$file); // get relative path from plugins dir
		$file = trim($file, '/');
		
		return $file;
		
	}

	/**
	* Gets the filesystem directory path (with trailing slash) for the plugin __FILE__ passed in
	* @package WordPress
	* @subpackage Plugin
	* @since 2.8
	*
	* @param string $file The filename of the plugin (__FILE__)
	* @return string the filesystem path of the directory that contains the plugin
	*/
	
	public function plugin_dir_path( $file ) {
	    
		return trailingslashit( dirname( $file ) );
	}

	/**
	* Gets the URL directory path (with trailing slash) for the plugin __FILE__ passed in
	* @package WordPress
	* @subpackage Plugin
	* @since 2.8
	*
	* @param string $file The filename of the plugin (__FILE__)
	* @return string the URL path of the directory that contains the plugin
	*/
	
	public function plugin_dir_url( $file ) {
	    
		return trailingslashit( plugins_url( '', $file ) );
	}

	/**
	* Set the activation hook for a plugin.
	*
	* When a plugin is activated, the action 'activate_PLUGINNAME' hook is
	* activated. In the name of this hook, PLUGINNAME is replaced with the name of
	* the plugin, including the optional subdirectory. For example, when the plugin
	* is located in wp-content/plugin/sampleplugin/sample.php, then the name of
	* this hook will become 'activate_sampleplugin/sample.php'. When the plugin
	* consists of only one file and is (as by default) located at
	* wp-content/plugin/sample.php the name of this hook will be
	* 'activate_sample.php'.
	*
	* @package WordPress
	* @subpackage Plugin
	* @since 2.0
	*
	* @param string $file The filename of the plugin including the path.
	* @param callback $function the function hooked to the 'activate_PLUGIN' action.
	*/
	
	public function register_activation_hook($file, $function) {
	    
		$file = plugin_basename($file);
		self::add_action('activate_' . $file, $function);
		
	}

	/**
	* Set the deactivation hook for a plugin.
	*
	* When a plugin is deactivated, the action 'deactivate_PLUGINNAME' hook is
	* deactivated. In the name of this hook, PLUGINNAME is replaced with the name
	* of the plugin, including the optional subdirectory. For example, when the
	* plugin is located in wp-content/plugin/sampleplugin/sample.php, then
	* the name of this hook will become 'activate_sampleplugin/sample.php'.
	*
	* When the plugin consists of only one file and is (as by default) located at
	* wp-content/plugin/sample.php the name of this hook will be
	* 'activate_sample.php'.
	*
	* @package WordPress
	* @subpackage Plugin
	* @since 2.0
	*
	* @param string $file The filename of the plugin including the path.
	* @param callback $function the function hooked to the 'activate_PLUGIN' action.
	*/
	
	public function register_deactivation_hook($file, $function) {
	    
		$file = plugin_basename($file);
		self::add_action('deactivate_' . $file, $function);
	}

	/**
	* Set the uninstallation hook for a plugin.
	*
	* Registers the uninstall hook that will be called when the user clicks on the
	* uninstall link that calls for the plugin to uninstall itself. The link won't
	* be active unless the plugin hooks into the action.
	*
	* The plugin should not run arbitrary code outside of functions, when
	* registering the uninstall hook. In order to run using the hook, the plugin
	* will have to be included, which means that any code laying outside of a
	* function will be run during the uninstall process. The plugin should not
	* hinder the uninstall process.
	*
	* If the plugin can not be written without running code within the plugin, then
	* the plugin should create a file named 'uninstall.php' in the base plugin
	* folder. This file will be called, if it exists, during the uninstall process
	* bypassing the uninstall hook. The plugin, when using the 'uninstall.php'
	* should always check for the 'WP_UNINSTALL_PLUGIN' constant, before
	* executing.
	*
	* @since 2.7
	*
	* @param string $file
	* @param callback $callback The callback to run when the hook is called. Must be a static method or function.
	*/
	public function register_uninstall_hook( $file, $callback ) {
	    
		if( is_array( $callback ) && is_object( $callback[0] ) ) {
		    
			_doing_it_wrong( __FUNCTION__, __( 'Only a static class method or function can be used in an uninstall hook.' ), '3.1' );
			return;
		}

		// The option should not be autoloaded, because it is not needed in most
		// cases. Emphasis should be put on using the 'uninstall.php' way of
		// uninstalling the plugin.
		
		$uninstallable_plugins = (array) get_option('uninstall_plugins');
		$uninstallable_plugins[plugin_basename($file)] = $callback;
		
		update_option('uninstall_plugins', $uninstallable_plugins);
		
	}

	/**
	* Calls the 'all' hook, which will process the functions hooked into it.
	*
	* The 'all' hook passes all of the arguments or parameters that were used for
	* the hook, which this function was called for.
	*
	* This function is used internally for apply_filters(), do_action(), and
	* do_action_ref_array() and is not meant to be used from outside those
	* functions. This function does not check for the existence of the all hook, so
	* it will fail unless the all hook exists prior to this function call.
	*
	* @package WordPress
	* @subpackage Plugin
	* @since 2.5
	* @access private
	*
	* @uses $this->wp_filter Used to process all of the functions in the 'all' hook
	*
	* @param array $args The collected parameters from the hook that was called.
	* @param string $hook Optional. The hook name that was used to call the 'all' hook.
	*/
	public function call_all_hook($args) {

		reset( $this->wp_filter['all'] );
		
		do {
			foreach( (array) current($this->wp_filter['all']) as $the_ )
				if ( !is_null($the_['function']) )
					call_user_func_array($the_['function'], $args);

		} while ( next($this->wp_filter['all']) !== false );
		
	}

	/**
	* Build Unique ID for storage and retrieval.
	*
	* The old way to serialize the callback caused issues and this function is the
	* solution. It works by checking for objects and creating an a new property in
	* the class to keep track of the object and new objects of the same class that
	* need to be added.
	*
	* It also allows for the removal of actions and filters for objects after they
	* change class properties. It is possible to include the property $this->wp_filter_id
	* in your class and set it to "null" or a number to bypass the workaround.
	* However this will prevent you from adding new classes and any new classes
	* will overwrite the previous hook by the same class.
	*
	* Functions and static method callbacks are just returned as strings and
	* shouldn't have any speed penalty.
	*
	* @package WordPress
	* @subpackage Plugin
	* @access private
	* @since 2.2.3
	* @link http://trac.wordpress.org/ticket/3875
	*
	* @global array $this->wp_filter Storage for all of the filters and actions
	* @param string $tag Used in counting how many hooks were applied
	* @param callback $function Used for creating unique id
	* @param int|bool $priority Used in counting how many hooks were applied. If === false and $function is an object reference, we return the unique id only if it already has one, false otherwise.
	* @return string|bool Unique ID for usage as array key or false if $priority === false and $function is an object reference, and it does not already have a unique id.
	*/
	public function build_unique_id($tag, $function, $priority) {
	    
		static $filter_id_count = 0;

		if ( is_string($function) )
			return $function;

		if ( is_object($function) ) {
			// Closures are currently implemented as objects
			$function = array( $function, '' );
		} else {
			$function = (array) $function;
		}

		if (is_object($function[0]) ) {
		    
			// Object Class Calling
			if ( function_exists('spl_object_hash') ) {
				return spl_object_hash($function[0]) . $function[1];
			} else {
				$obj_idx = get_class($function[0]).$function[1];
				if ( !isset($function[0]->wp_filter_id) ) {
					if ( false === $priority )
						return false;
					$obj_idx .= isset($this->wp_filter[$tag][$priority]) ? count((array)$this->wp_filter[$tag][$priority]) : $filter_id_count;
					$function[0]->wp_filter_id = $filter_id_count;
					++$filter_id_count;
				} else {
					$obj_idx .= $function[0]->wp_filter_id;
				}

				return $obj_idx;
			}
		} else if ( is_string($function[0]) ) {
			// Static Calling
			return $function[0].$function[1];
		}

	}

    
}

?>